home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 January: Mac OS SDK / Dev.CD Jan 96 SDK / Dev.CD Jan 96 SDK1.toast / Development Kits (Disc 1) / AOCE / Development Tools / Interfaces / PInterfaces / OCEMessaging.p < prev    next >
Encoding:
Text File  |  1993-11-10  |  26.8 KB  |  1,205 lines  |  [TEXT/MPS ]
  1. {***********************************************************
  2.  
  3. Created: Monday, November 8, 1993 11:57AM
  4.  OCEMessaging.p
  5.  Pascal Interface to the Macintosh Libraries
  6.  
  7.   Copyright Apple Computer, Inc. 1990-1993
  8.   All rights reserved
  9.  
  10. ***********************************************************}
  11.  
  12.  
  13. {$IFC UNDEFINED UsingIncludes}
  14. {$SETC UsingIncludes:= 0}
  15. {$ENDC}
  16.  
  17. {$IFC NOT UsingIncludes}
  18.     UNIT OCEMessaging;
  19.     INTERFACE
  20. {$ENDC}
  21.  
  22. {$IFC UNDEFINED UsingOCEMessaging}
  23. {$SETC UsingOCEMessaging:= 1}
  24.  
  25. {$I+}
  26. {$SETC OCEMessagingIncludes:= UsingIncludes}
  27. {$SETC UsingIncludes:= 1}
  28.  
  29.  
  30. {$IFC UNDEFINED UsingDigitalSignature}
  31. {$I DigitalSignature.p}
  32. {$ENDC}
  33.  
  34. {$IFC UNDEFINED UsingFiles}
  35. {$I $$Shell(PInterfaces)Files.p}
  36. {$ENDC}
  37.  
  38. {$IFC UNDEFINED UsingOCE}
  39. {$I OCE.p}
  40. {$ENDC}
  41.  
  42. {$IFC UNDEFINED UsingOCEAuthDir}
  43. {$I OCEAuthDir.p}
  44. {$ENDC}
  45.  
  46. {$IFC UNDEFINED UsingTypes}
  47. {$I $$Shell(PInterfaces)Types.p}
  48. {$ENDC}
  49.  
  50. {$SETC UsingIncludes:= OCEMessagingIncludes}
  51.  
  52.  
  53.  
  54. {****************************************************************************}
  55. { Definitions common to OCEMessaging and to OCEMail. These relate to addressing,
  56. message ids and priorities, etc. }
  57.  
  58.  
  59. { Values of IPMPriority }
  60. CONST
  61. kIPMAnyPriority = 0;        { FOR FILTER ONLY }
  62. kIPMNormalPriority = 1;
  63.  
  64.  
  65.  
  66. TYPE
  67. IPMPriority = Byte;
  68.  
  69.  
  70. CONST
  71. { Values of IPMAccessMode }
  72. kIPMAtMark = 0;
  73. kIPMFromStart = 1;
  74. kIPMFromLEOM = 2;
  75. kIPMFromMark = 3;
  76.  
  77. TYPE
  78. IPMAccessMode = INTEGER;
  79.  
  80.  
  81. CONST
  82. kIPMUpdateMsgBit = 4;
  83. kIPMNewMsgBit = 5;
  84. kIPMDeleteMsgBit = 6;
  85.  
  86.  
  87.  
  88. { Values of IPMNotificationType }
  89. kIPMUpdateMsgMask    = $10;  {1<<kIPMUpdateMsgBit}
  90. kIPMNewMsgMask        = $20;  {1<<kIPMNewMsgBit}
  91. kIPMDeleteMsgMask    = $40;  {1<<kIPMDeleteMsgBit}
  92.  
  93.  
  94.  
  95. TYPE
  96. IPMNotificationType = Byte;
  97.  
  98.  
  99. CONST
  100. { Values of IPMSenderTag }
  101. kIPMSenderRStringTag = 0;
  102. kIPMSenderRecordIDTag = 1;
  103.  
  104. TYPE
  105. IPMSenderTag = INTEGER;
  106.  
  107.  
  108. CONST
  109. kIPMFromDistListBit = 0;
  110. kIPMDummyRecBit        = 1;
  111. kIPMFeedbackRecBit    = 2;    { should be redirected to feedback queue }
  112. kIPMReporterRecBit    = 3;    { should be redirected to reporter original queue }
  113. kIPMBCCRecBit        = 4;    { this recipient is blind to all recipients of message }
  114.  
  115.  
  116. { Values of OCERecipientOffsetFlags }
  117. kIPMFromDistListMask            = $01;  {1<<kIPMFromDistListBit}
  118. kIPMDummyRecMask                = $02;  {1<<kIPMDummyRecBit}
  119. kIPMFeedbackRecMask                = $04;  {1<<kIPMFeedbackRecBit}
  120. kIPMReporterRecMask                = $08;  {1<<kIPMReporterRecBit}
  121. kIPMBCCRecMask                    = $10;    {1<<kIPMBCCRecBit}
  122.  
  123.  
  124.  
  125. TYPE
  126. OCERecipientOffsetFlags = Byte;
  127.  
  128.  
  129. OCECreatorType = RECORD
  130.     msgCreator: OSType;
  131.     msgType: OSType;
  132.     END;
  133.  
  134.  
  135.  
  136.  
  137. CONST
  138. kIPMTypeWildCard        = 'ipmw';
  139.  
  140. kIPMFamilyUnspecified    = 0;
  141. kIPMFamilyWildCard        = '????';
  142.  
  143. { well known signature }
  144. kIPMSignature            = 'ipms';    { base type }
  145.  
  146. { well known message types }
  147. kIPMReportNotify        = 'rptn';    { routing feedback }
  148.  
  149. { well known message block types }
  150. kIPMEnclosedMsgType        = 'emsg';    { enclosed (nested) message }
  151. kIPMReportInfo            = 'rpti';    { recipient information }
  152. kIPMDigitalSignature     = 'dsig';    { digital signature }
  153.  
  154. { Values of IPMMsgFormat }
  155. kIPMOSFormatType = 1;
  156. kIPMStringFormatType = 2;
  157.  
  158.  
  159.  
  160. TYPE
  161. IPMMsgFormat = INTEGER;
  162.  
  163. IPMStringMsgType = Str32;
  164.  
  165. IPMMsgType = RECORD
  166.     format: IPMMsgFormat;                { IPMMsgFormat}
  167.     CASE INTEGER OF
  168.         1: (msgOSType: OCECreatorType);
  169.         2: (msgStrType: IPMStringMsgType);
  170.     END;
  171.  
  172.  
  173.  
  174. {
  175. Following are the known extension values for IPM addresses handled by Apple.
  176. We define the definition of the entn extension below.
  177. }
  178.  
  179. CONST
  180. kOCEalanXtn            = 'alan';
  181. kOCEentnXtn            = 'entn';            { entn = entity name (DSSpec: aka) }
  182. kOCEaphnXtn            = 'aphn';
  183.  
  184.  
  185.  
  186. {
  187. Following are the specific definitions for the extension for the standard
  188. OCEMail 'entn' addresses.  [Note, the actual extension is formatted as in
  189. IPMEntityNameExtension.]
  190. }
  191.  
  192. { entn extension forms }
  193. kOCEAddrXtn            = 'addr';
  194. kOCEQnamXtn            = 'qnam';
  195. kOCEAttrXtn            = 'attr';            { an attribute specification }
  196. kOCESpAtXtn            = 'spat';            { specific attribute }
  197.  
  198. {
  199. Following are the specific definitions for standard
  200. OCEMail 'aphn' extension value.  
  201.  
  202. All RStrings here are packed (e.g. truncated to length) and even padded (e.g.
  203. if length odd, then a pad byte (zero) should be introduced before the next field).
  204.  
  205. The extension value is in the packed form of the following structure:
  206.     RString        phoneNumber;
  207.     RString        modemType;
  208.     Str32        queueuName;
  209.  
  210. The body of phoneNumber compound RString is in the packed form of the following structure:
  211.     short         subType;
  212.     RString     countryCode;                // used when subType == kOCEUseHandyDial
  213.     RString        areaCode;                    // used when subType == kOCEUseHandyDial
  214.     RString        phone;                        // used when subType == kOCEUseHandyDial
  215.     RString        postFix;                    // used when subType == kOCEUseHandyDial
  216.     RString        nonHandyDialString;            // used when subType == kOCEDontUseHandyDial
  217. }
  218.  
  219. { phoneNumber sub type constants }
  220. CONST
  221. kOCEUseHandyDial        = 1;
  222. kOCEDontUseHandyDial    = 2;
  223.  
  224.  
  225.  
  226. TYPE
  227. ProtoOCEPackedRecipient = RECORD
  228.     dataLength:    INTEGER;
  229.     END;
  230.  
  231. CONST
  232. kOCEPackedRecipientMaxBytes    = (4096 - sizeof(ProtoOCEPackedRecipient));
  233.  
  234.  
  235. TYPE
  236. OCEPackedRecipient = RECORD
  237.     dataLength:    INTEGER;
  238.  
  239.     data: PACKED ARRAY[1..kOCEPackedRecipientMaxBytes] OF Byte;
  240.     END;
  241. OCEPackedRecipientPtr = ^OCEPackedRecipient;
  242.  
  243.  
  244. IPMEntnQueueExtension = RECORD
  245.     queueName: Str32;
  246.     END;
  247.  
  248.  
  249. IPMEntnAttributeExtension = RECORD                { kOCEAttrXtn }
  250.     attributeName: AttributeType;
  251.     END;
  252.  
  253.  
  254. IPMEntnSpecificAttributeExtension = RECORD        { kOCESpAtXtn }
  255.     attributeCreationID: AttributeCreationID;
  256.     attributeName: AttributeType;
  257.     END;
  258.  
  259.  
  260. { All IPM entn extensions fit within the following }
  261.  
  262. IPMEntityNameExtension = RECORD
  263.     subExtensionType: OSType;
  264.     CASE INTEGER OF
  265.         1:    (specificAttribute: IPMEntnSpecificAttributeExtension);
  266.         2:    (attribute: IPMEntnAttributeExtension);
  267.         3:    (queue: IPMEntnQueueExtension);
  268.     END;
  269.  
  270.  
  271. { addresses with kIPMNBPXtn should specify this nbp type }
  272. CONST
  273. kIPMWSReceiverNBPType = 'MsgReceiver';
  274.  
  275. TYPE
  276. IPMMsgID = RECORD
  277.     id: ARRAY[1..4] OF LONGINT;
  278.     END;
  279.  
  280.  
  281.  
  282. CONST
  283. { Values of IPMHeaderSelector }
  284. kIPMTOC = 0;
  285. kIPMSender = 1;
  286. kIPMProcessHint = 2;
  287. kIPMMessageTitle = 3;
  288. kIPMMessageType = 4;
  289. kIPMFixedInfo = 7;
  290.  
  291.  
  292.  
  293. TYPE
  294. IPMHeaderSelector = Byte;
  295.  
  296. IPMSender = RECORD
  297.     sendTag: IPMSenderTag;
  298.     CASE INTEGER OF
  299.         1:    (rString: RString);
  300.         2:    (rid: PackedRecordID);
  301.     END;
  302.  
  303. OCERecipient = DSSpec;
  304.  
  305.  
  306.  
  307.  
  308.  
  309. {****************************************************************************}
  310. { Definitions specific to OCEMessaging }
  311.  
  312. IPMContextRef = LONGINT;
  313. IPMQueueRef = LONGINT;
  314. IPMMsgRef = LONGINT;
  315. IPMSeqNum = LONGINT;
  316. IPMProcHint = Str32;
  317. IPMQueueName = Str32;
  318.  
  319.  
  320. IPMNoteProcPtr = ProcPtr;
  321.     { FUNCTION IPMNoteProcPtr(queue: IPMQueueRef; seqNum: IPMSeqNum;
  322.          notificationType: IPMNotificationType; userData: LONGINT): void;}
  323.  
  324.  
  325. IPMFixedHdrInfo = PACKED RECORD
  326.     version: INTEGER;
  327.     authenticated: BOOLEAN;
  328.     signatureEnclosed: BOOLEAN;        { digital signature enclosed }
  329.     msgSize: LONGINT;
  330.     notification: IPMNotificationType;
  331.     priority: IPMPriority;
  332.     blockCount: INTEGER;
  333.     originalRcptCount: INTEGER;        { original number of recipients }
  334.     refCon: LONGINT;                { Client defined data }
  335.     reserved: INTEGER;
  336.     creationTime: UTCTime;            { Time when it was created }
  337.     msgID: IPMMsgID;
  338.     family: OSType;                    { family this msg belongs (e.g. mail) }
  339.     END;
  340.  
  341.  
  342. CONST
  343. kIPMDeliveryNotificationBit        = 0;
  344. kIPMNonDeliveryNotificationBit    = 1;
  345. kIPMEncloseOriginalBit            = 2;
  346. kIPMSummaryReportBit            = 3;
  347. kIPMOriginalOnlyOnErrorBit        = 4;        { modify enclose original to only on error }
  348.  
  349.  
  350.  
  351. kIPMNoNotificationMask            = $00;
  352. kIPMDeliveryNotificationMask    = $01;  {1<<kIPMDeliveryNotificationBit}
  353. kIPMNonDeliveryNotificationMask    = $02;  {1<<kIPMNonDeliveryNotificationBit}
  354. kIPMDontEncloseOriginalMask        = $00;
  355. kIPMEncloseOriginalMask            = $04;  {1<<kIPMEncloseOriginalBit}
  356. kIPMImmediateReportMask            = $00;
  357. kIPMSummaryReportMask            = $08;  {1<<kIPMSummaryReportBit}
  358. kIPMOriginalOnlyOnErrorMask        = $10;  {1<<kIPMOriginalOnlyOnErrorBit}
  359. kIPMEncloseOriginalOnErrorMask    = kIPMOriginalOnlyOnErrorMask + kIPMEncloseOriginalMask;
  360.  
  361. { standard Non delivery codes }
  362. kIPMNoSuchRecipient                    =    $0001;
  363. kIPMRecipientMalformed                =    $0002;
  364. kIPMRecipientAmbiguous                =    $0003;
  365. kIPMRecipientAccessDenied            =    $0004;
  366. kIPMGroupExpansionProblem            =    $0005;
  367. kIPMMsgUnreadable                    =    $0006;
  368. kIPMMsgExpired                        =    $0007;
  369. kIPMMsgNoTranslatableContent        =    $0008;
  370. kIPMRecipientReqStdCont                =    $0009;
  371. kIPMRecipientReqSnapShot            =    $000A;
  372. kIPMNoTransferDiskFull                =    $000B;
  373. kIPMNoTransferMsgRejectedbyDest        =    $000C;
  374. kIPMNoTransferMsgTooLarge            =    $000D;
  375.  
  376. {***********************************************************************}
  377. {
  378. This is the structure that will be returned by enumerate and getmsginfo
  379. This definition is just to give you a template, the position of msgType
  380. is variable since this is a packed structure.  procHint and msgType are
  381. packed and even length padded.
  382. }
  383. TYPE
  384. IPMMsgInfo = PACKED RECORD
  385.     sequenceNum: IPMSeqNum;
  386.     userData: LONGINT;
  387.     respIndex: INTEGER;
  388.     padByte: Byte;
  389.     priority: IPMPriority;
  390.     msgSize: LONGINT;
  391.     originalRcptCount: INTEGER;
  392.     reserved: INTEGER;
  393.     creationTime: UTCTime;
  394.     msgID: IPMMsgID;
  395.     family: OSType;                { family this msg belongs to (e.g. mail) }
  396.     procHint: IPMProcHint;
  397.     msgType: IPMMsgType;
  398.     END;
  399.  
  400. IPMBlockType = OCECreatorType;
  401.  
  402. IPMTOC = RECORD
  403.     blockType: IPMBlockType;
  404.     blockOffset: LONGINT;
  405.     blockSize: LONGINT;
  406.     blockRefCon: LONGINT;
  407.     END;
  408.  
  409.  
  410.  
  411. {
  412. The following structure is just to describe the layout of the SingleFilter.
  413. Each field should be packed and word aligned when passed to the IPM ToolBox.
  414. }
  415.  
  416. IPMSingleFilter = PACKED RECORD
  417.     priority: IPMPriority;
  418.     padByte: Byte;
  419.     family: OSType;                { family this msg belongs (e.g. mail), '????' for all }
  420.     script: ScriptCode;            { Language Identifier }
  421.     hint: IPMProcHint;
  422.     msgType: IPMMsgType;
  423.     END;
  424.  
  425.  
  426. IPMFilter = RECORD
  427.     count: INTEGER;
  428.     sFilters: ARRAY[1..1] OF IPMSingleFilter;
  429.     END;
  430.  
  431.  
  432. {***********************************************************************}
  433. {
  434. Following structures define the “start” of a recipient report block and the
  435. elements of the array respectively.
  436. }
  437.  
  438. IPMReportBlockHeader = RECORD
  439.     msgID: IPMMsgID;            { message id of the original }
  440.     creationTime: UTCTime;    { creation time of the report }
  441.     END;
  442.  
  443.  
  444. OCERecipientReport = RECORD
  445.     rcptIndex: INTEGER;        { index of recipient in original message }
  446.     result: OSErr;            { result of sending letter to this recipient}
  447.     END;
  448.  
  449. {***********************************************************************}
  450. IPMParamHeader = RECORD
  451.     qLink: Ptr;
  452.     reservedH1: LONGINT;
  453.     reservedH2: LONGINT;
  454.     ioCompletion: ProcPtr;
  455.     ioResult: OSErr;
  456.     saveA5: LONGINT;
  457.     reqCode: INTEGER;
  458.     END;
  459.  
  460.  
  461. IPMOpenContextPB = RECORD
  462.     qLink: Ptr;
  463.     reservedH1: LONGINT;
  464.     reservedH2: LONGINT;
  465.     ioCompletion: ProcPtr;
  466.     ioResult: OSErr;
  467.     saveA5: LONGINT;
  468.     reqCode: INTEGER;
  469.  
  470.     contextRef: IPMContextRef;        { <--  Context reference to be used in further calls}
  471.     END;
  472.  
  473. IPMCloseContextPB = IPMOpenContextPB;
  474.  
  475.  
  476. IPMCreateQueuePB = RECORD
  477.     qLink: Ptr;
  478.     reservedH1: LONGINT;
  479.     reservedH2: LONGINT;
  480.     ioCompletion: ProcPtr;
  481.     ioResult: OSErr;
  482.     saveA5: LONGINT;
  483.     reqCode: INTEGER;
  484.  
  485.     filler1: LONGINT;
  486.     queue: ^OCERecipient;
  487.     identity: AuthIdentity;        { used only if queue is remote }
  488.     owner: ^PackedRecordID;            { used only if queue is remote }
  489.     END;
  490.  
  491. { For createqueue and deletequeue only queue and identity are used }
  492. IPMDeleteQueuePB = IPMCreateQueuePB;
  493.  
  494.  
  495. IPMOpenQueuePB = PACKED RECORD
  496.     qLink: Ptr;
  497.     reservedH1: LONGINT;
  498.     reservedH2: LONGINT;
  499.     ioCompletion: ProcPtr;
  500.     ioResult: OSErr;
  501.     saveA5: LONGINT;
  502.     reqCode: INTEGER;
  503.  
  504.     contextRef: IPMContextRef;
  505.     queue: ^OCERecipient;
  506.     identity: AuthIdentity;
  507.     filter: ^IPMFilter;
  508.     newQueueRef: IPMQueueRef;
  509.     notificationProc: IPMNoteProcPtr;
  510.     userData: LONGINT;
  511.     noteType: IPMNotificationType;
  512.     padByte: Byte;
  513.     reserved: LONGINT;
  514.     reserved2: LONGINT;
  515.     END;
  516.  
  517.  
  518. IPMCloseQueuePB = RECORD
  519.     qLink: Ptr;
  520.     reservedH1: LONGINT;
  521.     reservedH2: LONGINT;
  522.     ioCompletion: ProcPtr;
  523.     ioResult: OSErr;
  524.     saveA5: LONGINT;
  525.     reqCode: INTEGER;
  526.  
  527.     queueRef: IPMQueueRef;
  528.     END;
  529.  
  530.  
  531. IPMEnumerateQueuePB = RECORD
  532.     qLink: Ptr;
  533.     reservedH1: LONGINT;
  534.     reservedH2: LONGINT;
  535.     ioCompletion: ProcPtr;
  536.     ioResult: OSErr;
  537.     saveA5: LONGINT;
  538.     reqCode: INTEGER;
  539.  
  540.     queueRef: IPMQueueRef;
  541.     startSeqNum: IPMSeqNum;
  542.     getProcHint: BOOLEAN;
  543.     getMsgType: BOOLEAN;
  544.     filler: INTEGER;
  545.     filter: ^IPMFilter;
  546.     numToGet: INTEGER;
  547.     numGotten: INTEGER;
  548.     enumCount: LONGINT;
  549.     enumBuffer: Ptr;        { will be packed array of IPMMsgInfo }
  550.     actEnumCount: LONGINT;
  551.     END;
  552.  
  553. IPMChangeQueueFilterPB = IPMEnumerateQueuePB;
  554.  
  555.  
  556. IPMDeleteMsgRangePB = RECORD
  557.     qLink: Ptr;
  558.     reservedH1: LONGINT;
  559.     reservedH2: LONGINT;
  560.     ioCompletion: ProcPtr;
  561.     ioResult: OSErr;
  562.     saveA5: LONGINT;
  563.     reqCode: INTEGER;
  564.  
  565.     queueRef: IPMQueueRef;
  566.     startSeqNum: IPMSeqNum;
  567.     endSeqNum: IPMSeqNum;
  568.     lastSeqNum: IPMSeqNum;
  569.     END;
  570.  
  571.  
  572.  
  573. IPMOpenMsgPB = PACKED RECORD
  574.     qLink: Ptr;
  575.     reservedH1: LONGINT;
  576.     reservedH2: LONGINT;
  577.     ioCompletion: ProcPtr;
  578.     ioResult: OSErr;
  579.     saveA5: LONGINT;
  580.     reqCode: INTEGER;
  581.  
  582.     queueRef: IPMQueueRef;
  583.     sequenceNum: IPMSeqNum;
  584.     newMsgRef: IPMMsgRef;
  585.     actualSeqNum: IPMSeqNum;
  586.     exactMatch: BOOLEAN;
  587.     padByte: Byte;
  588.     reserved: LONGINT;
  589.     END;
  590.  
  591.  
  592.  
  593. IPMOpenHFSMsgPB = RECORD
  594.     qLink: Ptr;
  595.     reservedH1: LONGINT;
  596.     reservedH2: LONGINT;
  597.     ioCompletion: ProcPtr;
  598.     ioResult: OSErr;
  599.     saveA5: LONGINT;
  600.     reqCode: INTEGER;
  601.  
  602.     hfsPath: ^FSSpec;
  603.     filler: LONGINT;
  604.     newMsgRef: IPMMsgRef;
  605.     filler2: LONGINT;
  606.     filler3: Byte;
  607.     reserved: LONGINT;
  608.     END;
  609.  
  610.  
  611.  
  612. IPMOpenBlockAsMsgPB = RECORD
  613.     qLink: Ptr;
  614.     reservedH1: LONGINT;
  615.     reservedH2: LONGINT;
  616.     ioCompletion: ProcPtr;
  617.     ioResult: OSErr;
  618.     saveA5: LONGINT;
  619.     reqCode: INTEGER;
  620.  
  621.     msgRef: IPMMsgRef;
  622.     filler: LONGINT;
  623.     newMsgRef: IPMMsgRef;
  624.     filler2: ARRAY[1..7] OF INTEGER;
  625.     blockIndex: INTEGER;
  626.     END;
  627.  
  628.  
  629.  
  630. IPMCloseMsgPB = RECORD
  631.     qLink: Ptr;
  632.     reservedH1: LONGINT;
  633.     reservedH2: LONGINT;
  634.     ioCompletion: ProcPtr;
  635.     ioResult: OSErr;
  636.     saveA5: LONGINT;
  637.     reqCode: INTEGER;
  638.  
  639.     msgRef: IPMMsgRef;
  640.     deleteMsg: BOOLEAN;
  641.     END;
  642.  
  643.  
  644.  
  645. IPMGetMsgInfoPB = RECORD
  646.     qLink: Ptr;
  647.     reservedH1: LONGINT;
  648.     reservedH2: LONGINT;
  649.     ioCompletion: ProcPtr;
  650.     ioResult: OSErr;
  651.     saveA5: LONGINT;
  652.     reqCode: INTEGER;
  653.  
  654.     msgRef: IPMMsgRef;
  655.     info: ^IPMMsgInfo;
  656.     END;
  657.  
  658.  
  659.  
  660. IPMReadHeaderPB = RECORD
  661.     qLink: Ptr;
  662.     reservedH1: LONGINT;
  663.     reservedH2: LONGINT;
  664.     ioCompletion: ProcPtr;
  665.     ioResult: OSErr;
  666.     saveA5: LONGINT;
  667.     reqCode: INTEGER;
  668.  
  669.     msgRef: IPMMsgRef;
  670.     fieldSelector: INTEGER;
  671.     offset: LONGINT;
  672.     count: LONGINT;
  673.     buffer: Ptr;
  674.     actualCount: LONGINT;
  675.     filler: INTEGER;
  676.     remaining: LONGINT;
  677.     END;
  678.  
  679.  
  680.  
  681. IPMReadRecipientPB = PACKED RECORD
  682.     qLink: Ptr;
  683.     reservedH1: LONGINT;
  684.     reservedH2: LONGINT;
  685.     ioCompletion: ProcPtr;
  686.     ioResult: OSErr;
  687.     saveA5: LONGINT;
  688.     reqCode: INTEGER;
  689.  
  690.     msgRef: IPMMsgRef;
  691.     rcptIndex: INTEGER;
  692.     offset: LONGINT;
  693.     count: LONGINT;
  694.     buffer: Ptr;
  695.     actualCount: LONGINT;
  696.     reserved: INTEGER;                { must be zero }
  697.     remaining: LONGINT;
  698.     originalIndex: INTEGER;
  699.     recipientOffsetFlags: OCERecipientOffsetFlags;
  700.     END;
  701.  
  702.  
  703.  
  704. {
  705. replyQueue works like recipient. [can no longer read it via ReadHeader]
  706. OriginalIndex is meaningless, rcptFlags are used seperately and there are
  707. currently none defined.
  708. }
  709. IPMReadReplyQueuePB = IPMReadRecipientPB;
  710.  
  711.  
  712. IPMGetBlkIndexPB = RECORD
  713.     qLink: Ptr;
  714.     reservedH1: LONGINT;
  715.     reservedH2: LONGINT;
  716.     ioCompletion: ProcPtr;
  717.     ioResult: OSErr;
  718.     saveA5: LONGINT;
  719.     reqCode: INTEGER;
  720.  
  721.     msgRef: IPMMsgRef;
  722.     blockType: IPMBlockType;
  723.     index: INTEGER;
  724.     startingFrom: INTEGER;
  725.     actualBlockType: IPMBlockType;
  726.     actualBlockIndex: INTEGER;
  727.     END;
  728.  
  729.  
  730.  
  731. IPMReadMsgPB = RECORD
  732.     qLink: Ptr;
  733.     reservedH1: LONGINT;
  734.     reservedH2: LONGINT;
  735.     ioCompletion: ProcPtr;
  736.     ioResult: OSErr;
  737.     saveA5: LONGINT;
  738.     reqCode: INTEGER;
  739.  
  740.     msgRef: IPMMsgRef;
  741.     mode: IPMAccessMode;
  742.     offset: LONGINT;
  743.     count: LONGINT;
  744.     buffer: Ptr;
  745.     actualCount: LONGINT;
  746.     blockIndex: INTEGER;
  747.     remaining: LONGINT;
  748.     END;
  749.  
  750.  
  751. IPMVerifySignaturePB = RECORD
  752.     qLink: Ptr;
  753.     reservedH1: LONGINT;
  754.     reservedH2: LONGINT;
  755.     ioCompletion: ProcPtr;
  756.     ioResult: OSErr;
  757.     saveA5: LONGINT;
  758.     reqCode: INTEGER;
  759.  
  760.     msgRef: IPMMsgRef;
  761.     signatureContext: SIGContextPtr;
  762.     END;
  763.  
  764.  
  765. IPMNewMsgPB = RECORD
  766.     qLink: Ptr;
  767.     reservedH1: LONGINT;
  768.     reservedH2: LONGINT;
  769.     ioCompletion: ProcPtr;
  770.     ioResult: OSErr;
  771.     saveA5: LONGINT;
  772.     reqCode: INTEGER;
  773.  
  774.     filler: LONGINT;
  775.     recipient: ^OCERecipient;
  776.     replyQueue: ^OCERecipient;
  777.     procHint: StringPtr;
  778.     filler2: INTEGER;
  779.     msgType: ^IPMMsgType;
  780.     refCon: LONGINT;
  781.     newMsgRef: IPMMsgRef;
  782.     filler3: INTEGER;
  783.     filler4: LONGINT;
  784.     identity: AuthIdentity;
  785.     sender: ^IPMSender;
  786.     internalUse: LONGINT;
  787.     internalUse2: LONGINT;
  788.     END;
  789.  
  790.  
  791. IPMNewHFSMsgPB = RECORD
  792.     qLink: Ptr;
  793.     reservedH1: LONGINT;
  794.     reservedH2: LONGINT;
  795.     ioCompletion: ProcPtr;
  796.     ioResult: OSErr;
  797.     saveA5: LONGINT;
  798.     reqCode: INTEGER;
  799.  
  800.     hfsPath: ^FSSpec;
  801.     recipient: ^OCERecipient;
  802.     replyQueue: ^OCERecipient;
  803.     procHint: StringPtr;
  804.     filler2: INTEGER;
  805.     msgType: ^IPMMsgType;
  806.     refCon: LONGINT;
  807.     newMsgRef: IPMMsgRef;
  808.     filler3: INTEGER;
  809.     filler4: LONGINT;
  810.     identity: AuthIdentity;
  811.     sender: ^IPMSender;
  812.     internalUse: LONGINT;
  813.     internalUse2: LONGINT;
  814.     END;
  815.  
  816.  
  817. IPMNestMsgPB = RECORD
  818.     qLink: Ptr;
  819.     reservedH1: LONGINT;
  820.     reservedH2: LONGINT;
  821.     ioCompletion: ProcPtr;
  822.     ioResult: OSErr;
  823.     saveA5: LONGINT;
  824.     reqCode: INTEGER;
  825.  
  826.     msgRef: IPMMsgRef;
  827.     filler: ARRAY[1..9] OF INTEGER;
  828.     refCon: LONGINT;
  829.     msgToNest: IPMMsgRef;
  830.     filler2: INTEGER;
  831.     startingOffset: LONGINT;
  832.     END;
  833.  
  834.  
  835.  
  836. IPMNewNestedMsgBlockPB = RECORD
  837.     qLink: Ptr;
  838.     reservedH1: LONGINT;
  839.     reservedH2: LONGINT;
  840.     ioCompletion: ProcPtr;
  841.     ioResult: OSErr;
  842.     saveA5: LONGINT;
  843.     reqCode: INTEGER;
  844.  
  845.     msgRef: IPMMsgRef;
  846.     recipient: ^OCERecipient;
  847.     replyQueue: ^OCERecipient;
  848.     procHint: StringPtr;
  849.     filler1: INTEGER;
  850.     msgType: ^IPMMsgType;
  851.     refCon: LONGINT;
  852.     newMsgRef: IPMMsgRef;
  853.     filler2: INTEGER;
  854.     startingOffset: LONGINT;
  855.     identity: AuthIdentity;
  856.     sender: ^IPMSender;
  857.     internalUse: LONGINT;
  858.     internalUse2: LONGINT;
  859.     END;
  860.  
  861.  
  862.  
  863. IPMEndMsgPB = PACKED RECORD
  864.     qLink: Ptr;
  865.     reservedH1: LONGINT;
  866.     reservedH2: LONGINT;
  867.     ioCompletion: ProcPtr;
  868.     ioResult: OSErr;
  869.     saveA5: LONGINT;
  870.     reqCode: INTEGER;
  871.  
  872.     msgRef: IPMMsgRef;
  873.     msgID: IPMMsgID;
  874.     msgTitle: ^RString;
  875.     deliveryNotification: IPMNotificationType;
  876.     priority: IPMPriority;
  877.     cancel: BOOLEAN;
  878.     padByte: Byte;
  879.     reserved: LONGINT;
  880.     signature: SIGSignaturePtr;
  881.     signatureSize: Size;
  882.     signatureContext: SIGContextPtr;
  883.     family: OSType;                                { family this msg belongs (e.g. mail) }
  884.                                                 { use kIPMFamilyUnspecified by default }
  885.     END;
  886.  
  887.  
  888.  
  889. IPMAddRecipientPB = RECORD
  890.     qLink: Ptr;
  891.     reservedH1: LONGINT;
  892.     reservedH2: LONGINT;
  893.     ioCompletion: ProcPtr;
  894.     ioResult: OSErr;
  895.     saveA5: LONGINT;
  896.     reqCode: INTEGER;
  897.  
  898.     msgRef: IPMMsgRef;
  899.     recipient: ^OCERecipient;
  900.     reserved: LONGINT;
  901.     END;
  902.  
  903.  
  904.  
  905. IPMAddReplyQueuePB = RECORD
  906.     qLink: Ptr;
  907.     reservedH1: LONGINT;
  908.     reservedH2: LONGINT;
  909.     ioCompletion: ProcPtr;
  910.     ioResult: OSErr;
  911.     saveA5: LONGINT;
  912.     reqCode: INTEGER;
  913.  
  914.     msgRef: IPMMsgRef;
  915.     filler: LONGINT;
  916.     replyQueue: ^OCERecipient;
  917.     END;
  918.  
  919.  
  920.  
  921. IPMNewBlockPB = RECORD
  922.     qLink: Ptr;
  923.     reservedH1: LONGINT;
  924.     reservedH2: LONGINT;
  925.     ioCompletion: ProcPtr;
  926.     ioResult: OSErr;
  927.     saveA5: LONGINT;
  928.     reqCode: INTEGER;
  929.  
  930.     msgRef: IPMMsgRef;
  931.     blockType: IPMBlockType;
  932.     filler: ARRAY[1..5] OF INTEGER;
  933.     refCon: LONGINT;
  934.     filler2: ARRAY[1..3] OF INTEGER;
  935.     startingOffset: LONGINT;
  936.     END;
  937.  
  938.  
  939.  
  940. IPMWriteMsgPB = RECORD
  941.     qLink: Ptr;
  942.     reservedH1: LONGINT;
  943.     reservedH2: LONGINT;
  944.     ioCompletion: ProcPtr;
  945.     ioResult: OSErr;
  946.     saveA5: LONGINT;
  947.     reqCode: INTEGER;
  948.  
  949.     msgRef: IPMMsgRef;
  950.     mode: IPMAccessMode;
  951.     offset: LONGINT;
  952.     count: LONGINT;
  953.     buffer: Ptr;
  954.     actualCount: LONGINT;
  955.     currentBlock: BOOLEAN;
  956.     END;
  957.  
  958.  
  959.  
  960.  
  961. IPMParamBlock = RECORD
  962.     CASE INTEGER OF
  963.          1:    (header: IPMParamHeader);
  964.          2:    (openContextPB: IPMOpenContextPB);
  965.          3:    (closeContextPB: IPMCloseContextPB);
  966.          4:    (createQueuePB: IPMCreateQueuePB);
  967.          5:    (deleteQueuePB: IPMDeleteQueuePB);
  968.          6:    (openQueuePB: IPMOpenQueuePB);
  969.          7:    (closeQueuePB: IPMCloseQueuePB);
  970.          8:    (enumerateQueuePB: IPMEnumerateQueuePB);
  971.          9:    (changeQueueFilterPB: IPMChangeQueueFilterPB);
  972.         10:    (deleteMsgRangePB: IPMDeleteMsgRangePB);
  973.         11:    (openMsgPB: IPMOpenMsgPB);
  974.         12:    (openHFSMsgPB: IPMOpenHFSMsgPB);
  975.         13:    (openBlockAsMsgPB: IPMOpenBlockAsMsgPB);
  976.         14:    (closeMsgPB: IPMCloseMsgPB);
  977.         15:    (getMsgInfoPB: IPMGetMsgInfoPB);
  978.         16:    (readHeaderPB: IPMReadHeaderPB);
  979.         17:    (readRecipientPB: IPMReadRecipientPB);
  980.         18:    (readReplyQueuePB: IPMReadReplyQueuePB);
  981.         19:    (getBlkIndexPB: IPMGetBlkIndexPB);
  982.         20:    (readMsgPB: IPMReadMsgPB);
  983.         21:    (verifySignaturePB: IPMVerifySignaturePB);
  984.         22:    (newMsgPB: IPMNewMsgPB);
  985.         23:    (newHFSMsgPB: IPMNewHFSMsgPB);
  986.         24:    (nestMsgPB: IPMNestMsgPB);
  987.         25:    (newNestedMsgBlockPB: IPMNewNestedMsgBlockPB);
  988.         26:    (endMsgPB: IPMEndMsgPB);
  989.         27:    (addRecipientPB: IPMAddRecipientPB);
  990.         28:    (addReplyQueuePB: IPMAddReplyQueuePB);
  991.         29:    (newBlockPB: IPMNewBlockPB);
  992.         30:    (writeMsgPB: IPMWriteMsgPB);
  993.     END;
  994.  
  995. IPMParamBlockPtr = ^IPMParamBlock;
  996.  
  997. CONST
  998. {    Request codes }
  999. kIPMOpenContext                = $400;
  1000. kIPMCloseContext            = $401;
  1001. kIPMNewMsg                    = $402;
  1002. kIPMAddRecipient            = $403;
  1003. kIPMNewBlock                = $404;
  1004. kIPMNewNestedMsgBlock        = $405;
  1005. kIPMNestMsg                    = $406;
  1006. kIPMWriteMsg                = $407;
  1007. kIPMEndMsg                    = $408;
  1008. kIPMOpenQueue                = $409;
  1009. kIPMCloseQueue                = $40A;
  1010. kIPMOpenMsg                    = $40B;
  1011. kIPMCloseMsg                = $40C;
  1012. kIPMReadMsg                    = $40D;
  1013. kIPMReadHeader                = $40E;
  1014. kIPMOpenBlockAsMsg            = $40F;
  1015. kIPMReadRecipient            = $410;
  1016. kIPMCreateQueue                = $411;
  1017. kIPMDeleteQueue                = $412;
  1018. kIPMEnumerateQueue            = $413;
  1019. kIPMChangeQueueFilter        = $414;
  1020. kIPMDeleteMsgRange            = $415;
  1021. kIPMOpenHFSMsg                = $417;
  1022. kIPMGetBlkIndex                = $418;
  1023. kIPMGetMsgInfo                = $419;
  1024.  
  1025. kIPMAddReplyQueue            = $41D;
  1026. kIPMNewHFSMsg                = $41E;
  1027.  
  1028. kIPMReadReplyQueue            = $421;
  1029. kIPMVerifySignature            = $422;
  1030.  
  1031.  
  1032.  
  1033.  
  1034. FUNCTION IPMOpenContext(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1035.     INLINE $3F3C, kIPMOpenContext, _oceTBDispatch;
  1036.  
  1037. FUNCTION IPMCloseContext(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1038.     INLINE $3F3C, kIPMCloseContext, _oceTBDispatch;
  1039.  
  1040. FUNCTION IPMNewMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1041.     INLINE $3F3C, kIPMNewMsg, _oceTBDispatch;
  1042.  
  1043. FUNCTION IPMNewBlock(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1044.     INLINE $3F3C, kIPMNewBlock, _oceTBDispatch;
  1045.  
  1046. FUNCTION IPMNewNestedMsgBlock(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1047.     INLINE $3F3C, kIPMNewNestedMsgBlock, _oceTBDispatch;
  1048.  
  1049. FUNCTION IPMNestMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1050.     INLINE $3F3C, kIPMNestMsg, _oceTBDispatch;
  1051.  
  1052. FUNCTION IPMWriteMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1053.     INLINE $3F3C, kIPMWriteMsg, _oceTBDispatch;
  1054.  
  1055. FUNCTION IPMEndMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1056.     INLINE $3F3C, kIPMEndMsg, _oceTBDispatch;
  1057.  
  1058. FUNCTION IPMOpenQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1059.     INLINE $3F3C, kIPMOpenQueue, _oceTBDispatch;
  1060.  
  1061. FUNCTION IPMCloseQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1062.     INLINE $3F3C, kIPMCloseQueue, _oceTBDispatch;
  1063.  
  1064. FUNCTION IPMVerifySignature(paramBlock: IPMParamBlockPtr): OSErr;        { Always synchronous }
  1065.     INLINE $7000, $1f00, $3F3C, kIPMVerifySignature, _oceTBDispatch;
  1066.  
  1067. FUNCTION IPMOpenMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1068.     INLINE $3F3C, kIPMOpenMsg, _oceTBDispatch;
  1069.  
  1070. FUNCTION IPMCloseMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1071.     INLINE $3F3C, kIPMCloseMsg, _oceTBDispatch;
  1072.  
  1073. FUNCTION IPMReadMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1074.     INLINE $3F3C, kIPMReadMsg, _oceTBDispatch;
  1075.  
  1076. FUNCTION IPMReadHeader(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1077.     INLINE $3F3C, kIPMReadHeader, _oceTBDispatch;
  1078.  
  1079. FUNCTION IPMOpenBlockAsMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1080.     INLINE $3F3C, kIPMOpenBlockAsMsg, _oceTBDispatch;
  1081.  
  1082. FUNCTION IPMNewHFSMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1083.     INLINE $3F3C, kIPMNewHFSMsg, _oceTBDispatch;
  1084.  
  1085. FUNCTION IPMReadRecipient(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1086.     INLINE $3F3C, kIPMReadRecipient, _oceTBDispatch;
  1087.  
  1088. FUNCTION IPMReadReplyQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1089.     INLINE $3F3C, kIPMReadReplyQueue, _oceTBDispatch;
  1090.  
  1091. FUNCTION IPMCreateQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1092.     INLINE $3F3C, kIPMCreateQueue, _oceTBDispatch;
  1093.  
  1094. FUNCTION IPMDeleteQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1095.     INLINE $3F3C, kIPMDeleteQueue, _oceTBDispatch;
  1096.  
  1097. FUNCTION IPMEnumerateQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1098.     INLINE $3F3C, kIPMEnumerateQueue, _oceTBDispatch;
  1099.  
  1100. FUNCTION IPMChangeQueueFilter(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1101.     INLINE $3F3C, kIPMChangeQueueFilter, _oceTBDispatch;
  1102.  
  1103. FUNCTION IPMDeleteMsgRange(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1104.     INLINE $3F3C, kIPMDeleteMsgRange, _oceTBDispatch;
  1105.  
  1106. FUNCTION IPMAddRecipient(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1107.     INLINE $3F3C, kIPMAddRecipient, _oceTBDispatch;
  1108.  
  1109. FUNCTION IPMAddReplyQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1110.     INLINE $3F3C, kIPMAddReplyQueue, _oceTBDispatch;
  1111.  
  1112. FUNCTION IPMOpenHFSMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1113.     INLINE $3F3C, kIPMOpenHFSMsg, _oceTBDispatch;
  1114.  
  1115. FUNCTION IPMGetBlkIndex(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1116.     INLINE $3F3C, kIPMGetBlkIndex, _oceTBDispatch;
  1117.  
  1118. FUNCTION IPMGetMsgInfo(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1119.     INLINE $3F3C, kIPMGetMsgInfo, _oceTBDispatch;
  1120.  
  1121.  
  1122.  
  1123.  
  1124. {**************************************************************************************}
  1125. { EXTERNAL ROUTINES }
  1126.  
  1127. CONST
  1128. kOCESizePackedRecipient        = 830;
  1129. kOCEPackRecipient            = 831;
  1130. kOCEUnpackRecipient            = 832;
  1131. kOCEStreamRecipient            = 833;
  1132. kOCEGetRecipientType        = 834;
  1133. kOCESetRecipientType        = 835;
  1134.  
  1135.  
  1136.  
  1137. {
  1138. Compute the space that a OCERecipient would take if it were in packed
  1139. form.  [Note: does NOT even pad extensionSize, so you may get an odd #back out]
  1140. Safe to pass dereferenced handle(s).
  1141. }
  1142.  
  1143. FUNCTION OCESizePackedRecipient(rcpt: OCERecipient): INTEGER;
  1144.     INLINE $303C, kOCESizePackedRecipient, $AA5C;
  1145.  
  1146.  
  1147. {
  1148. Take an OCERecipient (scatter) and (gather) stream into the specified
  1149. buffer.  It is assumed that there is sufficient space in the buffer (that is
  1150. OCESizePackedRecipient).  Safe to pass dereferenced handle(s).
  1151. }
  1152. FUNCTION OCEPackRecipient(rcpt: OCERecipient; buffer: UNIV Ptr): INTEGER;
  1153.     INLINE $303C, kOCEPackRecipient, $AA5C;
  1154.  
  1155. {
  1156. Take a packed OCERecipient and cast a the OCERecipient frame over it. Returns
  1157. amBadDestId if it doesn't look like an OCERecipient. Safe to pass dereferenced
  1158. handle(s).
  1159. }
  1160. FUNCTION OCEUnpackRecipient(buffer: UNIV Ptr; VAR rcpt: OCERecipient;
  1161.         VAR entitySpecifier: RecordID): OSErr;
  1162.     INLINE $303C, kOCEUnpackRecipient, $AA5C;
  1163.  
  1164.  
  1165. {
  1166. Take an OCERecipient (scatter) and (gather) stream using the specified
  1167. function.  Safe to pass dereferenced handle(s).  If streamer function returns
  1168. OCEError OCEStreamRecipient stops execution and passes the error back to the caller
  1169. }
  1170.  
  1171. TYPE
  1172. OCERecipientStreamer = ProcPtr;
  1173.     { FUNCTION OCERecipientStreamer(
  1174.         VAR buffer: void; count: LONGINT; eof: BOOLEAN; userData: LONGINT): OSErr;}
  1175.  
  1176.  
  1177.  
  1178. FUNCTION OCEStreamRecipient(rcpt: OCERecipient; stream: OCERecipientStreamer;
  1179.         userData: LONGINT; VAR actualCount: LONGINT): OSErr;
  1180.     INLINE $303C, kOCEStreamRecipient, $AA5C;
  1181.  
  1182.  
  1183. { Get the OCERecipient's extensionType. Safe to pass dereferenced handle(s).}
  1184.  
  1185. FUNCTION OCEGetRecipientType(cid: CreationID): OSType;
  1186.     INLINE $303C, kOCEGetRecipientType, $AA5C;
  1187.  
  1188.  
  1189. {
  1190. Set the OCERecipient's extensionType in the specified cid.  (Note: we do NOT
  1191. check for a nil pointer).  If the extensionType is 'entn', the cid is assumed
  1192. to be "valid" and is not touched.  Note: to properly handle non 'entn''s this
  1193. routine must and will zero the high LONGINT (source) of the cid! Safe to pass
  1194. dereferenced handle(s).
  1195. }
  1196. PROCEDURE OCESetRecipientType(extensionType: OSType; VAR cid: CreationID);
  1197.     INLINE $303C, kOCESetRecipientType, $AA5C;
  1198.  
  1199.  
  1200. {$ENDC}    { UsingOCEMessaging }
  1201.  
  1202. {$IFC NOT UsingIncludes}
  1203.     END.
  1204. {$ENDC}
  1205.